home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / game / think / AmiChess.lha / AmiChess / src / init.c < prev    next >
C/C++ Source or Header  |  2002-10-31  |  12KB  |  586 lines
  1. #include <clib/alib_protos.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <signal.h>
  6. #include "common.h"
  7.  
  8. #define NBITS 16
  9.  
  10. void Initialize()
  11. {
  12. InitLzArray();
  13. InitBitPosArray();
  14. InitMoveArray();
  15. InitRay();
  16. InitFromToRay();
  17. InitRankFileBit();
  18. InitPassedPawnMask();
  19. InitIsolaniMask();
  20. InitSquarePawnMask();
  21. InitBitCount();
  22. InitRotAtak();
  23. InitRandomMasks();
  24. InitDistance();
  25. InitVars();
  26. InitHashCode();
  27. InitHashTable();
  28. CalcHashKey();
  29. }
  30.  
  31. void InitLzArray()
  32. {
  33. int i,j,s,n;
  34. s=n=1;
  35. for(i=0;i<NBITS;i++)
  36.     {
  37.     for(j=s;j<s+n;j++) lzArray[j]=NBITS-1-i;
  38.     s+=n;
  39.     n+=n;
  40.     }
  41. }
  42.  
  43. void InitBitPosArray()
  44. {
  45. BitBoard b;
  46. short i;
  47. b=(BitBoard)1;
  48. for(i=63;i>=0;i--,b<<=1)
  49.     {
  50.     BitPosArray[i]=b;
  51.     NotBitPosArray[i]=~b;
  52.     }
  53. }
  54.  
  55. static const short dir[8][8]=
  56. {
  57. {0,0,0,0,0,0,0,0},
  58. {9,11,0,0,0,0,0,0},
  59. {-21,-19,-12,-8,8,12,19,21},
  60. {-11,-9,9,11,0,0,0,0},
  61. {-10,-1,1,10,0,0,0,0},
  62. {-11,-10,-9,-1,1,9,10,11},
  63. {-11,-10,-9,-1,1,9,10,11},
  64. {-9,-11,0,0,0,0,0,0}
  65. };
  66. static const short ndir[8]={0,2,8,4,4,8,8,2};
  67.  
  68. static const short map[120]=
  69. {
  70. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  71. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  72. -1,0,1,2,3,4,5,6,7,-1,
  73. -1,8,9,10,11,12,13,14,15,-1,
  74. -1,16,17,18,19,20,21,22,23,-1,
  75. -1,24,25,26,27,28,29,30,31,-1,
  76. -1,32,33,34,35,36,37,38,39,-1,
  77. -1,40,41,42,43,44,45,46,47,-1,
  78. -1,48,49,50,51,52,53,54,55,-1,
  79. -1,56,57,58,59,60,61,62,63,-1,
  80. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  81. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
  82. };
  83.  
  84.  
  85. void InitMoveArray()
  86. {
  87. short piece,fsq,tsq,f,t,n;
  88. BitBoard *b;
  89. for(piece=pawn;piece<=bpawn;piece++)
  90.     {
  91.     for(fsq=0;fsq<120;fsq++)
  92.         {
  93.         if((f=map[fsq])==-1) continue;
  94.         b=&MoveArray[piece][f];
  95.         *b=NULLBITBOARD;
  96.         for(n=0;n<ndir[piece];n++)
  97.             {
  98.             tsq=fsq;
  99.             do
  100.                 {
  101.                 tsq+=dir[piece][n];
  102.                 if((t=map[tsq])!=-1) SETBIT(*b,t);
  103.                 }
  104.             while(range[piece]&&t!=-1);
  105.             }
  106.         }
  107.     }
  108. }
  109.  
  110. void InitRay()
  111. {
  112. short piece,fsq,tsq,f,t,n,ray;
  113. BitBoard *b;
  114. memset(directions,-1,sizeof(directions));
  115. for(fsq=0;fsq<120;fsq++)
  116.     {
  117.     if((f=map[fsq])==-1) continue;
  118.     ray=-1;
  119.     for(piece=bishop;piece<=rook;piece++)
  120.         {
  121.         for(n=0;n<ndir[piece];n++)
  122.             {
  123.             b=&Ray[f][++ray];
  124.             *b=NULLBITBOARD;
  125.             tsq=fsq;
  126.             do
  127.                 {
  128.                 tsq+=dir[piece][n];
  129.                 if((t=map[tsq])!=-1)
  130.                     {
  131.                     SETBIT(*b,t);
  132.                     directions[f][t]=ray;
  133.                     }
  134.                 }
  135.             while(t!=-1);
  136.             }
  137.         }
  138.     }
  139. }
  140.  
  141.  
  142. void InitFromToRay()
  143. {
  144. short piece,fsq,tsq,f,t,n;
  145. BitBoard *b;
  146. memset(FromToRay,0,sizeof(FromToRay));
  147. for(piece=bishop;piece<=rook;piece++)
  148.     {
  149.     for(fsq=0;fsq<120;fsq++)
  150.         {
  151.         if((f=map[fsq])==-1) continue;
  152.         for(n=0;n<ndir[piece];n++)
  153.             {
  154.             tsq=fsq;
  155.             t=map[tsq];
  156.             do
  157.                 {
  158.                 b=&FromToRay[f][t];
  159.                 tsq+=dir[piece][n];      
  160.                 if((t=map[tsq])!=-1)
  161.                     {
  162.                     SETBIT(FromToRay[f][t],t);
  163.                     FromToRay[f][t]|=*b;
  164.                     }
  165.                 }
  166.             while(t!=-1);
  167.             }
  168.         }
  169.     }
  170. }
  171.  
  172.  
  173. void InitRankFileBit()
  174. {
  175. BitBoard b;
  176. short i;
  177. i=8;
  178. b=(BitBoard)255;
  179. while(i--)
  180.     {
  181.     RankBit[i]=b;
  182.     b<<=8;
  183.     }
  184. i=8;
  185. b=0x0101010101010101ULL;
  186. while(i--)
  187.     {
  188.     FileBit[i]=b;
  189.     b<<=1;
  190.     }
  191. }
  192.  
  193.  
  194. void InitRandomMasks()
  195. {
  196. mask_kr_trapped_w[0]=BitPosArray[H2];
  197. mask_kr_trapped_w[1]=BitPosArray[H1]|BitPosArray[H2];
  198. mask_kr_trapped_w[2]=BitPosArray[G1]|BitPosArray[H1]|BitPosArray[H2];
  199. mask_qr_trapped_w[0]=BitPosArray[A2];
  200. mask_qr_trapped_w[1]=BitPosArray[A1]|BitPosArray[A2];
  201. mask_qr_trapped_w[2]=BitPosArray[A1]|BitPosArray[B1]|BitPosArray[A2];
  202. mask_kr_trapped_b[0]=BitPosArray[H7];
  203. mask_kr_trapped_b[1]=BitPosArray[H8]|BitPosArray[H7];
  204. mask_kr_trapped_b[2]=BitPosArray[H8]|BitPosArray[G8]|BitPosArray[H7];
  205. mask_qr_trapped_b[0]=BitPosArray[A7];
  206. mask_qr_trapped_b[1]=BitPosArray[A8]|BitPosArray[A7];
  207. mask_qr_trapped_b[2]=BitPosArray[A8]|BitPosArray[B8]|BitPosArray[A7];
  208. }
  209.  
  210. void InitPassedPawnMask()
  211. {
  212. unsigned short sq;
  213. memset(PassedPawnMask,0,sizeof(PassedPawnMask));
  214. for(sq=0;sq<64;sq++)
  215.     {
  216.     PassedPawnMask[white][sq]=Ray[sq][7];
  217.     if(ROW(sq))    PassedPawnMask[white][sq]|=Ray[sq-1][7];
  218.     if(ROW(sq)!=7)    PassedPawnMask[white][sq]|=Ray[sq+1][7];
  219.     }
  220. for(sq=0;sq<64;sq++)
  221.     {
  222.     PassedPawnMask[black][sq]=Ray[sq][4];
  223.     if(ROW(sq)) PassedPawnMask[black][sq]|=Ray[sq-1][4];
  224.     if(ROW(sq)!=7) PassedPawnMask[black][sq]|=Ray[sq+1][4];
  225.     }
  226. }
  227.  
  228.  
  229. void InitIsolaniMask()
  230. {
  231. short i;
  232. IsolaniMask[0]=FileBit[1];
  233. IsolaniMask[7]=FileBit[6];
  234. for(i=1;i<=6;i++) IsolaniMask[i]=FileBit[i-1]|FileBit[i+1];
  235. }
  236.  
  237.  
  238. void InitSquarePawnMask()
  239. {
  240. unsigned short sq;
  241. short len,i,j;
  242. memset(SquarePawnMask,0,sizeof(PassedPawnMask));
  243. for(sq=0;sq<64;sq++)
  244.     {
  245.     len=7-RANK(sq);
  246.     i=MAX(sq&56,sq-len);
  247.     j=MIN(sq|7,sq+len);
  248.     while(i<=j)
  249.         {
  250.         SquarePawnMask[white][sq]|=(BitPosArray[i]|FromToRay[i][i|56]);
  251.         i++;
  252.         }
  253.     len=RANK(sq);
  254.     i=MAX(sq&56,sq-len);
  255.     j=MIN(sq|7,sq+len);
  256.     while(i<=j)
  257.         {
  258.         SquarePawnMask[black][sq]|=(BitPosArray[i]|FromToRay[i][i&7]);
  259.         i++;
  260.         }
  261.     }
  262. for(sq=A2;sq<=H2;sq++) SquarePawnMask[white][sq]=SquarePawnMask[white][sq+8];
  263. for(sq=A7;sq<=H7;sq++) SquarePawnMask[black][sq]=SquarePawnMask[black][sq-8];
  264. }
  265.  
  266. void InitBitCount()
  267. {
  268. int i,j,n;
  269. BitCount[0]=0;
  270. BitCount[1]=1;
  271. i=1;
  272. for(n=2;n<=16;n++)
  273.     {
  274.     i<<=1;
  275.     for(j=i;j<=i+(i-1);j++) BitCount[j]=1+BitCount[j-i];
  276.     }
  277. } 
  278.  
  279. void InitRotAtak()
  280. {
  281. short sq,map,sq1,sq2;
  282. short cmap[8]={128,64,32,16,8,4,2,1};
  283. short rot1[8]={A1,A2,A3,A4,A5,A6,A7,A8};
  284. short rot2[8]={A1,B2,C3,D4,E5,F6,G7,H8};
  285. short rot3[8]={A8,B7,C6,D5,E4,F3,G2,H1};
  286. for(sq=A1;sq<=H1;sq++)
  287.     {
  288.     for(map=0;map<256;map++)
  289.         {
  290.         Rook00Atak[sq][map]=0;
  291.         Rook90Atak[rot1[sq]][map]=0;
  292.         Bishop45Atak[rot2[sq]][map]=0;
  293.         Bishop315Atak[rot3[sq]][map]=0;
  294.         sq1=sq2=sq;
  295.         while(sq1>0)
  296.             {
  297.             if(cmap[--sq1]&map) break;
  298.             }
  299.         while(sq2<7)
  300.             {
  301.             if(cmap[++sq2]&map) break;
  302.             }
  303.         Rook00Atak[sq][map]=FromToRay[sq][sq1]|FromToRay[sq][sq2];
  304.         Rook90Atak[rot1[sq]][map]=FromToRay[rot1[sq]][rot1[sq1]]|
  305.         FromToRay[rot1[sq]][rot1[sq2]];
  306.         Bishop45Atak[rot2[sq]][map]=FromToRay[rot2[sq]][rot2[sq1]]|
  307.         FromToRay[rot2[sq]][rot2[sq2]];
  308.         Bishop315Atak[rot3[sq]][map]=FromToRay[rot3[sq]][rot3[sq1]]|
  309.         FromToRay[rot3[sq]][rot3[sq2]];
  310.         }
  311.     } 
  312. for(map=0;map<256;map++)
  313.     {
  314.     for(sq=A2;sq<=H8;sq++)
  315.         {
  316.         Rook00Atak[sq][map]=Rook00Atak[sq-8][map]>>8;
  317.         }
  318.     for(sq1=B_FILE;sq1<=H_FILE;sq1++)
  319.         {
  320.         for(sq2=0;sq2<64;sq2+=8)
  321.             {
  322.             sq=sq2+sq1;
  323.             Rook90Atak[sq][map]=Rook90Atak[sq-1][map]>>1;
  324.             }
  325.         }
  326.     for(sq1=B1,sq2=H7;sq1<=H1;sq1++,sq2-=8)
  327.         {
  328.         for(sq=sq1;sq<=sq2;sq+=9)
  329.             {
  330.             Bishop45Atak[sq][map]=Bishop45Atak[sq+8][map]<<8;
  331.             }
  332.         }
  333.     for(sq1=A2,sq2=G8;sq1<=A8;sq1+=8,sq2--)
  334.         {
  335.         for(sq=sq1;sq<=sq2;sq+=9)
  336.             {
  337.             Bishop45Atak[sq][map]=(Bishop45Atak[sq+1][map]&NotBitPosArray[sq1-8])<<1;
  338.             }
  339.         }
  340.     for(sq1=H2,sq2=B8;sq1<=H8;sq1+=8,sq2++)
  341.         {
  342.         for(sq=sq1;sq<=sq2;sq+=7)
  343.             {
  344.             Bishop315Atak[sq][map]=Bishop315Atak[sq-8][map]>>8;
  345.             }
  346.         }
  347.     for(sq1=G1,sq2=A7;sq1>=A1;sq1--,sq2-=8)
  348.         {
  349.         for(sq=sq1;sq<=sq2;sq+=7)
  350.             {
  351.             Bishop315Atak[sq][map]=(Bishop315Atak[sq+1][map]&NotBitPosArray[sq2+8])<<1;
  352.             }
  353.         }
  354.     }
  355. }
  356.  
  357.  
  358. void InitDistance()
  359. {
  360. short f,t,j;
  361. short d1,d2;
  362. for(f=0;f<64;f++) for(t=0;t<8;t++) DistMap[f][t]=0;
  363. for(f=0;f<64;f++) for(t=f;t<64;t++)
  364.     {
  365.     d1=(t&0x07)-(f&0x07);
  366.     if(d1<0)d1=-d1;
  367.     d2=(t>>3)-(f>>3);
  368.     if(d2<0)d2=-d2;
  369.     distance[f][t]=MAX(d1,d2);
  370.     distance[t][f]=MAX(d1,d2);
  371.     taxicab[f][t]=d1+d2;
  372.     taxicab[t][f]=d1+d2;
  373.     }
  374. for(f=0;f<64;f++) for(t=0;t<64;t++) DistMap[f][distance[t][f]]|=BitPosArray[t];
  375. for(f=0;f<64;f++) for(t=0;t<8;t++) for(j=0;j<t;j++) DistMap[f][t]|=DistMap[f][j];
  376. }
  377.  
  378.  
  379. void InitVars()
  380. {
  381. int i;
  382. memset(&board,0,sizeof(board));
  383. for(i=8;i<16;i++) SETBIT(board.b[white][pawn],i);
  384. SETBIT(board.b[white][rook],0);
  385. SETBIT(board.b[white][knight],1);
  386. SETBIT(board.b[white][bishop],2);
  387. SETBIT(board.b[white][queen],3);
  388. SETBIT(board.b[white][king],4);
  389. SETBIT(board.b[white][bishop],5);
  390. SETBIT(board.b[white][knight],6);
  391. SETBIT(board.b[white][rook],7);
  392. for(i=48;i<56;i++) SETBIT(board.b[black][pawn],i);
  393. SETBIT(board.b[black][rook],56);
  394. SETBIT(board.b[black][knight],57);
  395. SETBIT(board.b[black][bishop],58);
  396. SETBIT(board.b[black][queen],59);
  397. SETBIT(board.b[black][king],60);
  398. SETBIT(board.b[black][bishop],61);
  399. SETBIT(board.b[black][knight],62);
  400. SETBIT(board.b[black][rook],63);
  401. SETBIT(stonewall[white],D4);
  402. SETBIT(stonewall[white],E3);
  403. SETBIT(stonewall[white],F4);
  404. SETBIT(stonewall[black],D5);
  405. SETBIT(stonewall[black],E6);
  406. SETBIT(stonewall[black],F5);
  407. SETBIT(rings[0],D4);
  408. SETBIT(rings[0],D5);
  409. SETBIT(rings[0],E4);
  410. SETBIT(rings[0],E5);
  411. SETBIT(rings[1],C3);
  412. SETBIT(rings[1],D3);
  413. SETBIT(rings[1],E3);
  414. SETBIT(rings[1],F3);
  415. SETBIT(rings[1],C4);
  416. SETBIT(rings[1],F4);
  417. SETBIT(rings[1],C5);
  418. SETBIT(rings[1],F5);
  419. SETBIT(rings[1],C6);
  420. SETBIT(rings[1],D6);
  421. SETBIT(rings[1],E6);
  422. SETBIT(rings[1],F6);
  423. SETBIT(rings[2],B2);
  424. SETBIT(rings[2],C2);
  425. SETBIT(rings[2],D2);
  426. SETBIT(rings[2],E2);
  427. SETBIT(rings[2],F2);
  428. SETBIT(rings[2],G2);
  429. SETBIT(rings[2],B3);
  430. SETBIT(rings[2],G3);
  431. SETBIT(rings[2],B4);
  432. SETBIT(rings[2],G4);
  433. SETBIT(rings[2],B5);
  434. SETBIT(rings[2],G5);
  435. SETBIT(rings[2],B6);
  436. SETBIT(rings[2],G6);
  437. SETBIT(rings[2],B7);
  438. SETBIT(rings[2],C7);
  439. SETBIT(rings[2],D7);
  440. SETBIT(rings[2],E7);
  441. SETBIT(rings[2],F7);
  442. SETBIT(rings[2],G7);
  443. SETBIT(rings[3],A1);
  444. SETBIT(rings[3],B1);
  445. SETBIT(rings[3],C1);
  446. SETBIT(rings[3],D1);
  447. SETBIT(rings[3],E1);
  448. SETBIT(rings[3],F1);
  449. SETBIT(rings[3],G1);
  450. SETBIT(rings[3],H1);
  451. SETBIT(rings[3],A2);
  452. SETBIT(rings[3],H2);
  453. SETBIT(rings[3],A3);
  454. SETBIT(rings[3],H3);
  455. SETBIT(rings[3],A4);
  456. SETBIT(rings[3],H4);
  457. SETBIT(rings[3],A5);
  458. SETBIT(rings[3],H5);
  459. SETBIT(rings[3],A6);
  460. SETBIT(rings[3],H6);
  461. SETBIT(rings[3],A7);
  462. SETBIT(rings[3],H7);
  463. SETBIT(rings[3],A8);
  464. SETBIT(rings[3],B8);
  465. SETBIT(rings[3],C8);
  466. SETBIT(rings[3],D8);
  467. SETBIT(rings[3],E8);
  468. SETBIT(rings[3],F8);
  469. SETBIT(rings[3],G8);
  470. SETBIT(rings[3],H8);
  471. boardhalf[white]=RankBit[0]|RankBit[1]|RankBit[2]|RankBit[3];
  472. boardhalf[black]=RankBit[4]|RankBit[5]|RankBit[6]|RankBit[7];
  473. boardside[ks]=FileBit[4]|FileBit[5]|FileBit[6]|FileBit[7];
  474. boardside[qs]=FileBit[0]|FileBit[1]|FileBit[2]|FileBit[3];
  475. board.flag|=(WCASTLE|BCASTLE);
  476. board.side=white;
  477. DoMethod(mui_app,MUIM_Chess_Side);
  478. board.ep=-1;
  479. board.king[white]=E1;
  480. board.king[black]=E8;
  481. GameCnt=-1;
  482. Game50=0;
  483. computer=black;
  484. CalcHashKey();
  485. Game[0].hashkey=HashKey;
  486. board.pmaterial[white]=board.pmaterial[black]=2*ValueR+2*ValueN+2*ValueB+ValueQ;
  487. board.material[white]=board.material[black]=board.pmaterial[white]+8*ValueP;
  488. UpdateFriends();
  489. UpdateCBoard();
  490. UpdateMvboard();
  491. for(i=A1;i<=H8;i++)
  492.     {
  493.     if(cboard[i])
  494.         {
  495.         SETBIT(board.blockerr90,r90[i]);
  496.         SETBIT(board.blockerr45,r45[i]);
  497.         SETBIT(board.blockerr315,r315[i]);
  498.         }
  499.     }
  500.  
  501. TreePtr[0]=TreePtr[1]=Tree;
  502. SET(flags,USEHASH);
  503. /* SET(flags,USENULL);*/
  504. /* SearchTime=5; */
  505. /* SearchDepth=0; */
  506. MoveLimit[white]=MoveLimit[black]=TCMove;
  507. TimeLimit[white]=TimeLimit[black]=TCTime*60;
  508. board.castled[white]=board.castled[black]=false;
  509. phase=PHASE;
  510. i=HASHSLOTS;
  511. TTHashMask=0;
  512. while((i>>=1)>0)
  513.     {
  514.     TTHashMask<<=1;
  515.     TTHashMask|=1;
  516.     }
  517. HashSize=TTHashMask+1;
  518. i=PAWNSLOTS;
  519. PHashMask=0;
  520. while((i>>=1)>0)
  521.     {
  522.     PHashMask<<=1;
  523.     PHashMask|=1;
  524.     }
  525. DebugPly=99;
  526. DebugDepth=0;
  527. DebugNode=999999999;
  528. /* signal(SIGINT,EndSearch); */
  529. nmovesfrombook=0;
  530. }
  531.  
  532. void InitHashCode()
  533. {
  534. short color,piece,sq;
  535. for(color=white;color<=black;color++)
  536.     {
  537.     for(piece=pawn;piece<=king;piece++)
  538.         {
  539.         for(sq=0;sq<64;sq++) hashcode[color][piece][sq]=Rand64();
  540.         }
  541.     }
  542. for(sq=0;sq<64;sq++) ephash[sq]=Rand64();
  543. WKCastlehash=Rand64();
  544. WQCastlehash=Rand64();
  545. BKCastlehash=Rand64();
  546. BQCastlehash=Rand64();
  547. Sidehash=Rand64();
  548. }
  549.  
  550. void InitHashTable()
  551. {
  552. /* unsigned int size; */
  553. HashTab[0]=(HashSlot *)realloc(HashTab[0],HashSize*sizeof(HashSlot));
  554. HashTab[1]=(HashSlot *)realloc(HashTab[1],HashSize*sizeof(HashSlot));
  555. /*
  556. if(HashTab[0]==NULL||HashTab[1]==NULL) printf("Not enough memory for transposition table\n");
  557. else
  558.     {
  559.     size=(HashSize*2*sizeof(HashSlot))>>10;
  560.     printf("Transposition table:  Entries = %dK Size = %dK\n",HashSize>>10,size);
  561.     }
  562. */
  563. PawnTab[0]=(PawnSlot *)realloc(PawnTab[0],PAWNSLOTS*sizeof(PawnSlot));
  564. PawnTab[1]=(PawnSlot *)realloc(PawnTab[1],PAWNSLOTS*sizeof(PawnSlot));
  565. /*
  566. if(PawnTab[0]==NULL||PawnTab[1]==NULL) printf("Not enough memory for pawn table\n");
  567. else
  568.     {
  569.     size=(PAWNSLOTS*2*sizeof(PawnSlot))>>10;
  570.     printf("Pawn hash table: Entries = %dK Size = %dK\n",PAWNSLOTS>>10,size);
  571.     }
  572. */
  573. }
  574.  
  575. void NewPosition()
  576. {
  577. CLEAR(flags,ENDED);
  578. Game50=0;
  579. GameCnt=-1;
  580. Game[0].hashkey=HashKey;
  581. TTClear();
  582. PTClear();
  583. nmovesfrombook=0;
  584. ExchCnt[white]=ExchCnt[black]=0;
  585. }
  586.